home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Internet Tools 1993 July / Internet Tools.iso / RockRidge / mail / pp / pp-6.0 / Chans / x40084 / P1_in.py < prev    next >
Encoding:
Text File  |  1991-12-18  |  23.1 KB  |  930 lines
  1. -- P1: P1 MHS definitions
  2.  
  3.  
  4. -- @(#) $Header: /xtel/pp/pp-beta/Chans/x40084/RCS/P1_in.py,v 6.0 1991/12/18 20:13:50 jpo Rel $
  5. --
  6. -- $Log: P1_in.py,v $
  7. -- Revision 6.0  1991/12/18  20:13:50  jpo
  8. -- Release 6.0
  9. --
  10. -- 
  11. --
  12.  
  13.  
  14.  
  15. P1 DEFINITIONS ::=
  16.  
  17. %{
  18. #ifndef lint
  19. static char Rcsid[] = "@(#)$Header: /xtel/pp/pp-beta/Chans/x40084/RCS/P1_in.py,v 6.0 1991/12/18 20:13:50 jpo Rel $";
  20. #endif  lint
  21.  
  22. #include "head.h"
  23. #include "prm.h"
  24. #include "q.h"
  25. #include "or.h"
  26. #include "dr.h"
  27. #include <isode/cmd_srch.h>
  28.  
  29. #define PPSTRUCT        "/usr/pp/pp/logs/x400in84.pdus"
  30.  
  31. extern char             *loc_dom_site;
  32. extern char             *pp_myname;
  33. extern char             *remote_site;
  34. extern char        *undefined_bodyparts;
  35. extern char             *cont_p2;
  36.  
  37.  
  38. static DRmpdu           DRstruct;
  39. DRmpdu                  *DRptr = &DRstruct;
  40. static OR_ptr           orptr;
  41. static Q_struct         Qstruct;
  42. Q_struct                *PPQuePtr = &Qstruct;
  43. static int              ad_no;
  44.  
  45.  
  46. ADDR                    *adr_new();
  47. char                    *pe2str();
  48. char                    *body_string;
  49. int                     body_len;
  50.  
  51.  
  52. #ifdef  DEBUG
  53. int     testdebug (pe, s)
  54. register PE     pe;
  55. register char   *s;
  56. {
  57.     register PS ps;
  58.     static int debug = OK;
  59.     static FILE *fptrace;
  60.  
  61.     switch (debug) {
  62.         case NOTOK:
  63.             return;
  64.  
  65.         case OK:
  66.             debug = 1;
  67.             fflush (stdout);
  68.             if (access (PPSTRUCT, 02) == NOTOK) {
  69.                 debug = NOTOK;
  70.                 break;
  71.             }
  72.             fptrace = fopen (PPSTRUCT, "a");
  73.             if (fptrace == NULL) {
  74.                 debug = NOTOK;
  75.                 break;
  76.             }
  77.             fprintf (fptrace, "testdebug made with %s\n", pepyid);
  78.             /* and fall... */
  79.  
  80.         default:
  81.             fflush (stdout);
  82.             fprintf (fptrace, "%s\n", s);
  83.  
  84.             if ((ps = ps_alloc (std_open)) == NULLPS)
  85.                 break;
  86.             if (std_setup (ps, fptrace) != NOTOK)
  87.                 (void) pe2pl (ps, pe);
  88.             fprintf (fptrace, "--------\n");
  89.             (void) fflush (fptrace);
  90.             ps_free (ps);
  91.             break;
  92.     }
  93. }
  94.  
  95. #endif  /* DEBUG */
  96. %}
  97.  
  98. BEGIN
  99.  
  100. DECODER do
  101.  
  102.  
  103. -- P1 makes use of types defined in the following module:
  104. -- Sa: Recommendation S.a[14]
  105. -- T73: T.73, Section 5
  106.  
  107. MPDU ::=
  108.             %{
  109.                         q_init (PPQuePtr);   /* initialise Q struct */
  110.                         dr_init (&DRstruct); /* initialise DR struct */
  111.                         PPQuePtr->inbound =
  112.                                 list_rchan_new (remote_site, pp_myname);
  113.                         ad_no = 1;
  114.             %}
  115.  
  116.         CHOICE {
  117.             [0]
  118.                 IMPLICIT UserMPDU [[p PPQuePtr]],
  119.  
  120.                 -- service mpdus are sent as ordinary messages
  121.  
  122.                 ServiceMPDU [[p PPQuePtr]]
  123.         }
  124.  
  125.  
  126.  
  127. ServiceMPDU [[P Q_struct *]] ::=
  128.         CHOICE {
  129.             [1]
  130.                 IMPLICIT DeliveryReportMPDU [[p PPQuePtr]]
  131.                 %{
  132.                         PPQuePtr->msgtype = MT_DMPDU;
  133.                 %},
  134.  
  135.             [2]
  136.                 IMPLICIT ProbeMPDU [[p PPQuePtr]]
  137.                 %{
  138.                         PPQuePtr->msgtype = MT_PMPDU;
  139.                 %}
  140.         }
  141.  
  142.  
  143. UserMPDU [[P Q_struct *]] ::=
  144.         SEQUENCE {
  145.             envelope
  146.                 %{
  147.                         PPQuePtr->msgtype = MT_UMPDU;
  148.                         ad_no = 1;
  149.                 %}
  150.                 UMPDUEnvelope [[p PPQuePtr]],
  151.  
  152.             content
  153.                 UMPDUContent
  154.                 %{
  155.                         body_string = prim2str ($$, &body_len);
  156.                         PPQuePtr->msgsize = body_len;
  157.                 %}
  158.         }
  159.  
  160. UMPDUEnvelope [[P Q_struct *]] %{
  161.         ADDR    *ad_link;
  162.         char    *sp;
  163.         int     n;
  164.         %} ::=
  165.         SET {
  166.             mpduID
  167.                 MPDUIdentifier [[p &parm->msgid]],
  168.  
  169.             originator
  170.                 ORName [[p &sp]]
  171.                 %{
  172.                         parm->Oaddress = adr_new (sp, AD_X400_TYPE, 0);
  173.                 %},
  174.  
  175.             original
  176.                 EncodedInformationTypes
  177.                         [[p &parm->orig_encodedinfo]] OPTIONAL,
  178.  
  179.             ContentType [[i n]]
  180.             %{  if (n != 2) {
  181.                         PP_OPER (NULLCP, ("Bad content type %d aborting",n));
  182.                         exit (2);
  183.                 }
  184.                 parm->cont_type = strdup (cont_p2); 
  185.         %},
  186.  
  187.             UAContentId [[s parm->ua_id]] OPTIONAL,
  188.  
  189.             Priority [[i parm->priority]] DEFAULT normal,
  190.  
  191.             PerMessageFlag [[p parm]] DEFAULT {},
  192.  
  193.             deferredDelivery[0]
  194.                 IMPLICIT Time
  195.                         [[p &parm->defertime]] OPTIONAL,
  196.  
  197.             [1]
  198.                 IMPLICIT SEQUENCE OF
  199.                         PerDomainBilateralInfo
  200.                         OPTIONAL,
  201.  
  202.             [2]
  203.                 IMPLICIT SEQUENCE OF RecipientInfo [[p &ad_link]]
  204.                 %{
  205.                         register ADDR   **ap;
  206.                         for (ap = &(parm->Raddress);
  207.                                 *ap; ap = &(*ap)->ad_next);
  208.                         *ap = ad_link;
  209.                 %},
  210.  
  211.             TraceInformation [[p &parm->trace]],
  212.  
  213.             -- this one's for EAN
  214.             [UNIVERSAL 17]
  215.                 IMPLICIT ANY OPTIONAL
  216.         }
  217.  
  218.  
  219. UMPDUContent ::=
  220.         OCTETSTRING
  221.  
  222.  
  223. -- time
  224.  
  225. Time [[P UTC *]] ::=
  226.         UniversalTime
  227.         %{
  228.                 char    *p = pe2str ($$);
  229.                 UTC     ut;
  230.  
  231.                 ut = str2utct (p, strlen(p));
  232.                 if (ut) {
  233.                         *parm = (UTC) smalloc (sizeof *ut);
  234.                         **parm = *ut;
  235.                 } else
  236.               return NOTOK;
  237.                 free (p);
  238.         %}
  239.  
  240.  
  241. -- various envelope information
  242.  
  243. MPDUIdentifier [[P MPDUid *]] ::=
  244.         [APPLICATION 4] IMPLICIT SEQUENCE {
  245.             GlobalDomainIdentifier
  246.                 [[p &parm->mpduid_DomId]],
  247.  
  248.             IA5String [[s parm->mpduid_string]]
  249.         }
  250.  
  251.  
  252. ContentType ::=
  253.         [APPLICATION 6]
  254.             IMPLICIT INTEGER {
  255.                 p2 (2)
  256.             }
  257.  
  258.  
  259. UAContentId ::=
  260.         [APPLICATION 10]
  261.             IMPLICIT PrintableString
  262.  
  263.  
  264. Priority ::=
  265.         [APPLICATION 7]
  266.             IMPLICIT INTEGER {
  267.                 normal (0),
  268.  
  269.                 nonUrgent (1),
  270.  
  271.                 urgent (2)
  272.             }
  273.  
  274.  
  275. PerMessageFlag [[P Q_struct *]] ::=
  276.         [APPLICATION 8]
  277.             IMPLICIT BITSTRING {
  278.                 discloseRecipients (0),
  279.                 conversionProhibited (1),
  280.                 alternateRecipientAllowed (2),
  281.                 contentReturnRequest (3)
  282.             }
  283.         %{
  284.                 if (bit_test ($$, 0))
  285.                         parm -> disclose_recips = TRUE;
  286.         else    parm -> disclose_recips = FALSE;
  287.  
  288.                 if (bit_test ($$, 1))
  289.                         parm -> implicit_conversion_prohibited = TRUE;
  290.         else    parm -> implicit_conversion_prohibited = FALSE;
  291.  
  292.                 if (bit_test ($$, 2))
  293.                         parm -> alternate_recip_allowed = TRUE;
  294.         else    parm -> alternate_recip_allowed = FALSE;
  295.  
  296.                 if (bit_test ($$, 3))
  297.                         parm -> content_return_request = TRUE;
  298.         else    parm -> content_return_request = FALSE;
  299.         %}
  300.  
  301.  
  302.  
  303. -- per-domain bilateral information
  304. -- IGNORED!
  305.  
  306. PerDomainBilateralInfo ::=
  307.         SEQUENCE {
  308.             country
  309.                 CountryName,
  310.  
  311.                 AdministrationDomainName,
  312.  
  313.                 BilateralInfo
  314.         }
  315.  
  316. BilateralInfo ::=
  317.         ANY
  318.  
  319.  
  320. -- recipient information
  321.  
  322. RecipientInfo [[P ADDR **]]
  323.         %{
  324.                 char    *sp;
  325.                 int     anint;
  326.         %} ::=
  327.         SET {
  328.             recipient
  329.                 ORName [[p &sp]]
  330.                 %{
  331.                         *parm = adr_new (sp, AD_X400_TYPE, ad_no);
  332.                         ++ad_no;
  333.                 %},
  334.  
  335.             [0]
  336.                 IMPLICIT ExtensionIdentifier [[i (*parm)->ad_extension]],
  337.  
  338.             [1]
  339.                 IMPLICIT PerRecipientFlag [[p &anint]]
  340.                 %{
  341.                         prf2mem (anint, &(*parm)->ad_resp,
  342.                                         &(*parm)->ad_mtarreq,
  343.                                         &(*parm)->ad_usrreq);
  344.                 %},
  345.  
  346.             [2]
  347.                 IMPLICIT ExplicitConversion [[i anint]]
  348.                 %{
  349.                         (*parm)->ad_explicitconversion = anint;
  350.                 %}
  351.                 DEFAULT {}
  352.  
  353.             -- this one's for EAN --,
  354.             [UNIVERSAL 2]
  355.                 IMPLICIT INTEGER OPTIONAL
  356.         }
  357.  
  358. ExtensionIdentifier ::=
  359.         INTEGER
  360.  
  361. PerRecipientFlag [[P int *]] ::=
  362.         BITSTRING -- See Figure 23/X.411
  363.         %{
  364.                 *parm = pe2bits ($$);
  365.         %}
  366.  
  367. ExplicitConversion ::=
  368.         INTEGER {
  369.             iA5TextTeletex (0),
  370.  
  371.             teletexTelex (1)
  372.         }
  373.  
  374.  
  375.  
  376. -- trace information
  377.  
  378. TraceInformation [[P Trace **]] %{
  379.         Trace *newtrace;
  380.         %} ::=
  381.         [APPLICATION 9]
  382.             IMPLICIT SEQUENCE OF SEQUENCE {
  383.                 domainid
  384.             %{
  385.                 Trace   **tp;
  386.  
  387.                 newtrace = (Trace *) smalloc (sizeof (*newtrace));
  388.                 bzero ((char *) newtrace, sizeof (*newtrace));
  389.                 for (tp = parm; *tp; tp = &(*tp)->trace_next);
  390.                 *tp = newtrace;
  391.                 newtrace->trace_next = (Trace *) NULL;
  392.             %}
  393.                     GlobalDomainIdentifier
  394.                         [[p &newtrace->trace_DomId]],
  395.  
  396.                 domaininfo
  397.                     DomainSuppliedInfo
  398.                         [[p &newtrace->trace_DomSinfo]]
  399.             }
  400.  
  401.  
  402.  
  403. DomainSuppliedInfo [[P DomSupInfo *]] ::=
  404.         SET {
  405.             arrival[0]
  406.                 IMPLICIT Time [[p &parm->dsi_time]],
  407.  
  408.             deferred[1]
  409.                 IMPLICIT Time [[p &parm->dsi_deferred]]
  410.                         OPTIONAL,
  411.  
  412.             action[2]
  413.                 IMPLICIT INTEGER [[i parm->dsi_action]] {
  414.                     relayed (0),
  415.  
  416.                     rerouted (1)
  417.                 },
  418.  
  419.             converted
  420.                 EncodedInformationTypes
  421.                     [[p &parm->dsi_converted]] OPTIONAL,
  422.  
  423.             previous
  424.                 GlobalDomainIdentifier
  425.                     [[p &parm->dsi_attempted_md]] OPTIONAL
  426.         }
  427.  
  428.  
  429.  
  430. -- global domain identifier
  431.  
  432. GlobalDomainIdentifier [[P GlobalDomId *]] ::=
  433.         [APPLICATION 3]
  434.             IMPLICIT SEQUENCE {
  435.                 CountryName [[p &parm->global_Country]],
  436.                 AdministrationDomainName
  437.                     [[p &parm->global_Admin]],
  438.                 PrivateDomainIdentifier
  439.                     [[p &parm->global_Private]] OPTIONAL
  440.             }
  441.  
  442.  
  443. CountryName [[P char **]] ::=
  444.         [APPLICATION 1]
  445.             CHOICE {
  446.                 NumericString [[s *parm]],
  447.  
  448.                 PrintableString [[s *parm]]
  449.             }
  450.  
  451.  
  452. AdministrationDomainName [[P char **]] ::=
  453.         [APPLICATION 2]
  454.             CHOICE {
  455.                 NumericString [[s *parm]],
  456.                 PrintableString [[s *parm]]
  457.             }
  458.  
  459.  
  460. PrivateDomainIdentifier [[P char **]] ::=
  461.         CHOICE {
  462.             NumericString [[s *parm]],
  463.  
  464.             PrintableString [[s *parm]]
  465.         }
  466.  
  467.  
  468.  
  469. -- O/R name
  470.  
  471. ORName [[P char **]] 
  472.         %{ 
  473.                 PE      pe_standard = NULLPE; 
  474.                 PE      pe_domain = NULLPE; 
  475.                 char    buf[1024];
  476.         %} ::=
  477.         [APPLICATION 0]
  478.             IMPLICIT SEQUENCE {
  479.                 standard
  480.                         ANY
  481.                         [[a pe_standard]],
  482.  
  483.                 domaindefined
  484.                         ANY
  485.                         [[a pe_domain]]
  486.                         OPTIONAL 
  487.             }
  488.             %{
  489.                 *parm = NULLCP;
  490.                 if (decode_OR_StandardAttributeList 
  491.                         (pe_standard, 1, NULLIP, NULLVP, &orptr) == NOTOK) {
  492.                 (void) sprintf (buf, "problem decoding standard attributes: %s", PY_pepy);
  493.                                 advise (NULLCP, "%s", buf);
  494.                 or_free (orptr);
  495.                 return NOTOK;
  496.                 }
  497.  
  498.                  if (pe_domain && decode_OR_DomainDefinedAttributeList 
  499.                         (pe_domain, 1, NULLIP, NULLVP, &orptr) == NOTOK) {
  500.                 (void) sprintf (buf, "problem decoding DD: %s",
  501.                         PY_pepy);
  502.                                 advise (NULLCP, "%s", buf);
  503.                 or_free (orptr);
  504.                 return NOTOK;
  505.                 }
  506.                 or_or2std (orptr, buf, FALSE);
  507.                 *parm = strdup (buf);
  508.                 or_free (orptr);
  509.                 orptr = NULLOR;
  510.             %}
  511.  
  512.  
  513.  
  514. -- encoded information types
  515.  
  516. EncodedInformationTypes [[P EncodedIT *]] ::=
  517.         [APPLICATION 5] IMPLICIT SET {
  518.             [0]
  519.                 IMPLICIT BITSTRING {
  520.                     undefined (0),
  521.                     tLX (1),
  522.                     iA5Text (2),
  523.                     g3Fax (3),
  524.                     tIF0 (4),
  525.                     tTX (5),
  526.                     videotex (6),
  527.                     voice (7),
  528.                     sFD (8),
  529.                     tIF1 (9)
  530.                 }
  531.                 %{
  532.                         enctypes2mem (pe2bits ($$),
  533.                 undefined_bodyparts, &parm->eit_types);
  534.                 %}
  535.                 -- this OPTIONAL is for EAN -- OPTIONAL,
  536.  
  537.             [1]
  538.                 IMPLICIT G3NonBasicParams [[p &parm->eit_g3parms]]
  539.                 OPTIONAL,
  540.  
  541.             [2]
  542.                 IMPLICIT TeletexNonBasicParams OPTIONAL,
  543.  
  544.             [3]
  545.                 IMPLICIT PresentationCapabilities OPTIONAL
  546.  
  547.         -- other non-basic parameters are for further study
  548.  
  549.             -- but this one's for EAN --,
  550.             [UNIVERSAL 3]
  551.                 IMPLICIT BITSTRING {
  552.                     undefined (0),
  553.                     tLX (1),
  554.                     iA5Text (2),
  555.                     g3Fax (3),
  556.                     tIF0 (4),
  557.                     tTX (5),
  558.                     videotex (6),
  559.                     voice (7),
  560.                     sFD (8),
  561.                     tIF1 (9)
  562.                 }
  563.                 %{
  564.                         enctypes2mem (pe2bits ($$),
  565.                 undefined_bodyparts, &parm->eit_types);
  566.                 %} OPTIONAL
  567.         }
  568.  
  569. G3NonBasicParams [[P long *]] ::=
  570.         BITSTRING {
  571.             twoDimensional (8),
  572.             fineResolution (9),
  573.             unlimitedLength (20),
  574.             b4Length (21),
  575.             a3Width (22),
  576.             b4Width (23),
  577.             uncompressed (30)
  578.         }
  579.         %{ *parm = pe2bits ($$); %}
  580.  
  581. TeletexNonBasicParams ::=
  582.         SET {
  583.             graphicCharacterSets[0]
  584.                 IMPLICIT T61String OPTIONAL,
  585.  
  586.             controlCharacterSets[1]
  587.                 IMPLICIT T61String OPTIONAL,
  588.  
  589.             pageFormats[2]
  590.                 IMPLICIT OCTETSTRING OPTIONAL,
  591.  
  592.             miscTerminalCapabilities[3]
  593.                 IMPLICIT T61String OPTIONAL,
  594.  
  595.             privateUse[4]
  596.                 IMPLICIT OCTETSTRING OPTIONAL
  597.         }
  598.  
  599. PresentationCapabilities ::=
  600.         T73PresentationCapabilities
  601.  
  602.  
  603. T73PresentationCapabilities ::=
  604.         SET { --unimportant-- }
  605.  
  606.  
  607. -- Delivery Report MPDU
  608.  
  609. DeliveryReportMPDU [[P Q_struct *]]::=
  610.         %{ dr_init (&DRstruct); %}
  611.         SEQUENCE {
  612.             envelope
  613.                 DeliveryReportEnvelope [[p parm]],
  614.  
  615.             content
  616.                 DeliveryReportContent [[p parm]]
  617.         }
  618.  
  619.  
  620. DeliveryReportEnvelope [[P Q_struct *]] %{ char *sp; %} ::=
  621.         SET {
  622.             report %{
  623.                 DRptr -> dr_mpduid = (MPDUid *)
  624.                         smalloc (sizeof (MPDUid));
  625.                 bzero ((char *)DRptr -> dr_mpduid, sizeof (MPDUid));
  626.                 %}
  627.                 MPDUIdentifier [[p DRptr->dr_mpduid]],
  628.  
  629.             originator
  630.                 ORName [[p &sp]]
  631.                 %{
  632.                         parm->Oaddress = adr_new (sp, AD_X400_TYPE, 0);
  633.                         parm->Oaddress->ad_resp = YES;
  634.                 %},
  635.  
  636.             TraceInformation [[p &DRptr->dr_trace]]
  637.         }
  638.  
  639.  
  640. DeliveryReportContent [[P Q_struct *]] ::=
  641.         SET {
  642.             original
  643.                 MPDUIdentifier [[p &parm->msgid]],
  644.  
  645.             intermediate
  646.                 TraceInformation [[p &DRptr -> dr_subject_intermediate_trace]]
  647.                 OPTIONAL,
  648.  
  649.                 UAContentId [[s parm->ua_id]] OPTIONAL,
  650.  
  651.             [0]
  652.                 IMPLICIT SEQUENCE OF ReportedRecipientInfo
  653.                     [[p parm]],
  654.  
  655.             returned[1]
  656.                 IMPLICIT UMPDUContent 
  657.                 %{
  658.                         body_string = prim2str ($$, &body_len);
  659.                         PPQuePtr->msgsize = body_len;
  660.                 %} OPTIONAL,
  661.  
  662.             billingInformation[2]
  663.                 ANY OPTIONAL
  664.         }
  665.  
  666.  
  667. ReportedRecipientInfo [[P  Q_struct *]]
  668.         %{
  669.                 int     anint;
  670.                 Rrinfo   *rr;
  671.                 ADDR    *ap;
  672.          %} ::=
  673.         SET  %{
  674.                 Rrinfo    **rp;
  675.  
  676.                 rr = (Rrinfo *) smalloc (sizeof (*rr));
  677.                 bzero ((char *) rr, sizeof (*rr));
  678.                 for (rp = &DRptr -> dr_recip_list;
  679.                         *rp; rp = &(*rp)->rr_next);
  680.                 *rp = rr;
  681.         %}
  682.         {
  683.             recipient[0]
  684.                 %{
  685.                         if (orptr != NULLOR) {
  686.                                 or_free (orptr);
  687.                                 orptr = NULLOR;
  688.                         }
  689.                         ap = adr_new (NULLCP, AD_X400_TYPE, ad_no);
  690.                         rr -> rr_recip = ad_no ++;
  691.                         ap->ad_status = AD_STAT_DRWRITTEN;
  692.                         adr_add (&parm -> Raddress, ap);
  693.                 %}
  694.                 IMPLICIT ORName
  695.                         [[p &ap -> ad_value]],
  696.  
  697.             [1]
  698.                 IMPLICIT ExtensionIdentifier [[i ap->ad_extension]],
  699.  
  700.             [2]
  701.                 IMPLICIT PerRecipientFlag [[p &anint]]
  702.                 %{
  703.                         prf2mem (anint, &ap->ad_resp,
  704.                                         &ap->ad_mtarreq,
  705.                                         &ap->ad_usrreq);
  706.                 %},
  707.  
  708.             [3]
  709.                 IMPLICIT LastTraceInformation
  710.                         [[p rr]],
  711.  
  712.             intendedRecipient[4]
  713.                 %{
  714.                         rr -> rr_originally_intended_recip = 
  715.                                 (FullName *) smalloc(sizeof(FullName));
  716.             bzero ((char *) rr -> rr_originally_intended_recip,
  717.                 sizeof(FullName));
  718.                 %}
  719.                 IMPLICIT ORName
  720.                         [[p &rr->rr_originally_intended_recip -> fn_addr]]
  721.                         OPTIONAL,
  722.  
  723.             [5]
  724.                 IMPLICIT SupplementaryInformation
  725.                         [[s rr->rr_supplementary]] OPTIONAL
  726.         }
  727.  
  728.  
  729.  
  730. -- last trace information
  731.  
  732. LastTraceInformation [[P Rrinfo *]] ::=
  733.         SET {
  734.             arrival[0]
  735.                 IMPLICIT Time [[p &parm->rr_arrival]],
  736.  
  737.             converted
  738.                 %{
  739.                         parm->rr_converted = (EncodedIT *)
  740.                                 smalloc (sizeof (*parm->rr_converted));
  741.                         bzero ((char *) parm->rr_converted,
  742.                                 sizeof (*parm->rr_converted));
  743.                 %}
  744.  
  745.                 EncodedInformationTypes [[p parm->rr_converted]] OPTIONAL,
  746.  
  747.             [1]
  748.                 Report [[p &parm->rr_report]]
  749.         }
  750.  
  751.  
  752. Report [[P Report *]] ::=
  753.         CHOICE {
  754.             [0]
  755.                 IMPLICIT DeliveredInfo
  756.                         [[p &parm->rep.rep_dinfo]]
  757.                 %{
  758.                         parm->rep_type = DR_REP_SUCCESS;
  759.                 %},
  760.  
  761.             [1]
  762.                 IMPLICIT NonDeliveredInfo
  763.                         [[p &parm->rep.rep_ndinfo]]
  764.                 %{
  765.                         parm->rep_type = DR_REP_FAILURE;
  766.                 %}
  767.         }
  768.  
  769.  
  770. DeliveredInfo [[P Delinfo *]] ::=
  771.         SET {
  772.             delivery[0]
  773.                 IMPLICIT Time [[p &parm->del_time]],
  774.  
  775.             typeOfUA[1]
  776.                 %{
  777.                         parm->del_type = 0;
  778.                 %}
  779.                 IMPLICIT INTEGER [[i parm->del_type]] {
  780.                     public (0),
  781.  
  782.                     private (1)
  783.                 } DEFAULT public
  784.         }
  785.  
  786.  
  787. NonDeliveredInfo [[P NonDelinfo *]] ::=
  788.         SET {
  789.             [0]
  790.                 IMPLICIT ReasonCode [[i parm->nd_rcode]],
  791.  
  792.             [1]
  793.                 IMPLICIT DiagnosticCode [[i parm->nd_dcode]] OPTIONAL
  794.         }
  795.  
  796.  
  797. -- No ReasonCodes specifed because 84 should be able to accept 88 codes
  798. ReasonCode ::=
  799.         INTEGER 
  800.  
  801.  
  802. -- No DiagnosticCodes specifed because 84 should be able to accept 88 codes
  803. DiagnosticCode  ::=
  804.         INTEGER
  805.  
  806.  
  807. -- supplementary information
  808.  
  809. SupplementaryInformation ::=
  810.         PrintableString -- length limited and for further study
  811.  
  812.  
  813. -- Probe MPDU
  814.  
  815. ProbeMPDU [[P Q_struct *]]::=
  816.         ProbeEnvelope [[p parm]]
  817.  
  818. ProbeEnvelope [[P Q_struct *]] %{
  819.         char *sp;
  820.         ADDR *ad_link;
  821.         int     n;
  822.         %} ::=
  823.         SET {
  824.             probe
  825.                 MPDUIdentifier [[p &parm->msgid]],
  826.  
  827.             originator
  828.                 ORName [[p &sp]]
  829.                 %{
  830.                         parm->Oaddress = adr_new (sp, AD_X400_TYPE, 0);
  831.                 %},
  832.  
  833.                 ContentType [[i n]]
  834.                     %{  if (n != 2) {
  835.                         PP_OPER (NULLCP, ("Bad content type %d aborting", n));
  836.                         exit (2);
  837.                         }
  838.                         parm->cont_type = strdup (cont_p2);
  839.             %},
  840.  
  841.                 UAContentId [[s parm->ua_id]] OPTIONAL,
  842.  
  843.             original
  844.                 EncodedInformationTypes
  845.                          [[p &parm->orig_encodedinfo]] OPTIONAL,
  846.  
  847.                 TraceInformation [[p &parm->trace]],
  848.  
  849.                 PerMessageFlag [[p parm]]
  850.                 DEFAULT {},
  851.  
  852.             contentLength[0]
  853.                 IMPLICIT INTEGER [[i parm->msgsize]] OPTIONAL,
  854.  
  855.             [1]
  856.                 IMPLICIT SEQUENCE OF PerDomainBilateralInfo
  857.                 OPTIONAL,
  858.  
  859.             [2]
  860.                 IMPLICIT SEQUENCE OF
  861.                         RecipientInfo [[p &ad_link]]
  862.                 %{
  863.                         register ADDR   **ap;
  864.                         for (ap = &(parm->Raddress);
  865.                              *ap; ap = &(*ap)->ad_next);
  866.                                         *ap = ad_link;
  867.                 %}
  868. }
  869.  
  870. END
  871.  
  872.  
  873. %{
  874. int     pe2bits (pe)
  875. register PE     pe;
  876. {
  877.     int     i,
  878.             j,
  879.             k;
  880.  
  881.     j = 0;
  882.     for (k = 1 << (i = 0); i < sizeof (j) * 8; i++, k <<= 1) {
  883.         switch (bit_test (pe, i)) {
  884.             case NOTOK:
  885.                 break;
  886.  
  887.             default:
  888.                 j |= k;         /* fall */
  889.             case OK:
  890.                 continue;
  891.         }
  892.  
  893.         break;
  894.     }
  895.  
  896.     return (j);
  897. }
  898.  
  899. char    *pe2str (pe)
  900. PE      pe;
  901. {
  902.         int     len;
  903.  
  904.         return prim2str (pe, &len);
  905. }
  906.  
  907.  
  908. dump_struct ()
  909. {
  910.         FILE    *fp;
  911.  
  912.         if ((fp = fopen (PPSTRUCT, "a")) == NULL)
  913.         {
  914.                 advise (NULLCP, "Can't open %s", PPSTRUCT);
  915.                 return;
  916.         }
  917.         if (rp_isbad (wr_q (PPQuePtr, fp)) )
  918.                 advise (NULLCP, "Can't write Qstruct");
  919.         if (PPQuePtr->Oaddress != NULL)
  920.                 if (rp_isbad (wr_adr (PPQuePtr->Oaddress, fp, AD_ORIGINATOR)))
  921.                         advise (NULLCP, "Can't write Oaddress");
  922.         if (PPQuePtr->Raddress != NULL)
  923.                 if (rp_isbad (wr_adr (PPQuePtr->Raddress, fp, AD_RECIPIENT)))
  924.                         advise (NULLCP, "Can't write Raddress");
  925.         fputs ("-------------------------\n", fp);
  926.         (void) fclose (fp);
  927. }
  928.  
  929. %}
  930.